package buttonEvent;

import ihm.Fenetre;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;


public class ComputeListener implements ActionListener {
	Fenetre fenetre;

	public ComputeListener(Fenetre f){
		super();
		this.fenetre=f;

	}

	public void testDistanceEdition(){

		Byte[][] m1 = new Byte[162][99];
		Byte[][] m2 = new Byte[162][99];
		for(int i=0; i<162;i++){
			for(int j=0; j<99;j++){
				float un = (float) Math.random();
				float deux = (float) Math.random();
				if(un>0.5){
					m1[i][j]=1;
				}
				else{
					m1[i][j]=0;
				}
				if(deux>0.5){
					m2[i][j]=1;
				}
				else{
					m2[i][j]=0;
				}
			}
		}

		m2[0][0]=0;
		m2[0][1]=1;
		m2[1][0]=0;
		m2[1][1]=1;

		distanceEdition(m1,m2);
	}

	
	static int min(int a, int b, int c) {
		return Math.min(Math.min(a, b), c);
	}

	public int distanceEdition(Byte[][] matrice1, Byte[][] matrice2){
		int[] s1 = new int[16038];
		int[] s2 = new int[16038];
		int c=0;
		//On place nos deux matrices dans deux tableaux de int[].
		for(int f=0; f<162;f++){
			for(int b=0;b<99;b++){
				s1[c]=matrice1[f][b] & 0xff;
				s2[c]=matrice2[f][b] & 0xff;
				c++;
			}
		}

		int[][] d = new int[2][s2.length + 1];

		for (int j = 0; j <= s2.length; j++)
			d[1][j] = j;

		for (int i = 1; i <= s1.length; i++) {
			d[0][0] = d[1][0];
			d[1][0]++;
			for (int j = 1; j <= s2.length; j++) {
				d[0][j]= d[1][j];
				d[1][j] = min(
						d[0][j] + 1,
						d[1][j - 1] + 1,
						d[0][j - 1]
								+ ((s1[i - 1] == s2[j - 1]) ? 0
										: 1));
			}
		}
		System.out.println("DISTANCE EIDTION = "+d[1][s2.length]);
		return d[1][s2.length];
	}

	@Override
	public void actionPerformed(ActionEvent arg0) {
		/*
		 * - G�n�ration de la matric sous la forme :
		 * 		public int[] generateMatrice(Image);
		 * - Appel de l'algo d'analyse matriciel avec transformation en diff�rent format.
		 * - R�cup�ration de la donn�e trouv� sous forme de String
		 * - this.fenetre.getApercu().setText(resultat)
		 */
		testDistanceEdition();
		BufferedImage bufferedImage=fenetre.getPan().createImage();
		try{
			int w = bufferedImage.getWidth(null);
			int h = bufferedImage.getHeight(null);
			int[] rgbs = new int[w*h];
			int table[]=bufferedImage.getRGB(0, 0, w, h, rgbs, 0, w);
			try {
				ImageIO.write(bufferedImage,"jpg",new File("test.jpg"));
			} catch (IOException e) {
				e.printStackTrace();
			}
			for(int i =0;i<table.length;i++){
				if(table[i]==-16777216)
					table[i]=0;
				else if(table[i]==-1)
					table[i]=1;
			}
			Byte[][] BinaryMatrix=addEmpty(recadrage(this.generateMatrice(table,h,w)));
			dessineMatrice(BinaryMatrix);
		}catch (NullPointerException e) {
			fenetre.getApercu().setText("Fenetre Vide");
		}
		//this.generateMatrice();
		System.out.println("En attente des g�n�rateur de matrices, d'analyse de matrices...");
	}


	private Byte[][] generateMatrice(int[] table,int height,int width) {
		Byte[][] matrice = new Byte[height][width];
		int cpt=0;
		System.out.println(table.length+" "+height*width);
		for(int i=0;i<height;i++){
			for(int j=0;j<width;j++){
				matrice[i][j]=(byte) table[cpt];
				cpt++;
			}
		}
		return matrice;
	}

	private Byte[][] recadrage(Byte[][] matrice){
		int i=0;
		int j=0;
		double decalageGauche=Double.POSITIVE_INFINITY;
		double decalageDroite=Double.POSITIVE_INFINITY;
		for(i =0;i<matrice.length;i++){
			for(j=0;j<matrice[i].length;j++){
				if(matrice[i][j] == 1){
					if(i < decalageGauche){
						decalageGauche = i;
					}
					if(j < decalageDroite){
						decalageDroite=j;
					}
				}
			}

		}
		for(i=0;i<matrice.length;i++){
			for(j=0;j<matrice[i].length;j++){
				if(matrice[i][j] == 1){
					matrice[(int) (i-decalageGauche)][(int) (j-decalageDroite)]=1;
					matrice[i][j]=0;
				}
			}
		}
		return matrice;
	}
	public Byte[][] addEmpty(Byte[][] matrice){
		Byte[][] newMatrice = new Byte[matrice.length+2][matrice[1].length+2];
		for(int i=0;i<newMatrice.length;i++){
			for(int j=0;j<newMatrice[0].length;j++){
				if(i == 0 || j == 0 || i== newMatrice.length-1 || j == newMatrice[0].length -1){
					newMatrice[i][j]=0;
				}
				else{
					newMatrice[i][j]=matrice[i-1][j-1];
				}
			}
		}
		return newMatrice;
	}
	public void dessineMatrice(Byte[][] matrice){
		for(int i=0;i<matrice.length;i++){
			for(int j=0;j<matrice[i].length;j++){
				System.out.print(matrice[i][j]);
			}
			System.out.println("");
		}
	}
}
